3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
6 * Copyright (c) 2001-2019 *
7 * Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
9 * Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
10 * Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
11 \***************************************************************************/
14 * Gestion de l'authentification par sessions
15 * à utiliser pour valider l'accès (bloquant)
16 * ou pour reconnaître un utilisateur (non bloquant)
18 * @package SPIP\Core\Session
21 if (!defined('_ECRIRE_INC_VERSION')) {
26 $GLOBALS['visiteur_session'] = array(); # globale decrivant l'auteur
29 * 3 actions sur les sessions, selon le type de l'argument:
31 * - numerique: efface toutes les sessions de l'auteur (retour quelconque)
32 * - tableau: cree une session pour l'auteur decrit et retourne l'identifiant
33 * - bool: predicat de validite de la session indiquee par le cookie
35 * @uses supprimer_sessions()
36 * @uses ajouter_session()
37 * @uses verifier_session()
39 * @param int|array|bool $auteur
40 * @return bool|null|void
42 function inc_session_dist($auteur = false) {
43 if (is_numeric($auteur)) {
44 return supprimer_sessions($auteur, $auteur > 0);
46 if (is_array($auteur)) {
47 return ajouter_session($auteur);
49 return verifier_session($auteur);
56 * Supprimer toutes les vieilles sessions d'un auteur
58 * Cette fonction efface toutes les sessions appartenant a l'auteur
59 * On en profite pour effacer toutes les sessions
60 * creees il y a plus de 4*_RENOUVELLE_ALEA
61 * Tenir compte de l'ancien format ou les noms commencaient par "session_"
62 * et du meme coup des repertoires plats
64 * Attention : id_auteur peut etre negatif (cas des auteurs temporaires pendant le dump)
66 * @uses verifier_session()
67 * @uses fichier_session()
68 * @uses spip_session()
70 * @param int $id_auteur
71 * Identifiant d'auteur dont on veut supprimer les sessions
73 * Supprimer aussi les vieilles sessions des autres auteurs ?
74 * @param bool $actives
75 * false pour ne pas supprimer les sessions valides de $id_auteur.
76 * false revient donc a uniquement supprimer les vieilles sessions !
78 function supprimer_sessions($id_auteur, $toutes = true, $actives = true) {
80 spip_log("supprimer sessions auteur $id_auteur", "session");
81 if ($toutes or $id_auteur !== $GLOBALS['visiteur_session']['id_auteur']) {
82 if ($dir = opendir(_DIR_SESSIONS
)) {
83 $t = time() - (4 * _RENOUVELLE_ALEA
);
84 while (($f = readdir($dir)) !== false) {
85 if (preg_match(",^[^\d-]*(-?\d+)_\w{32}\.php[3]?$,", $f, $regs)) {
86 $f = _DIR_SESSIONS
. $f;
87 if (($actives and $regs[1] == $id_auteur) or ($t > filemtime($f))) {
95 spip_unlink(fichier_session('alea_ephemere', true));
98 // forcer le recalcul de la session courante
103 * Ajoute une session pour l'auteur décrit par un tableau issu d'un SELECT-SQL
105 * @uses spip_php_session_start() Lorsque session anonyme
107 * @uses preparer_ecriture_session()
108 * @uses fichier_session()
109 * @uses ecrire_fichier_session()
111 * @param array $auteur
112 * Description de la session de l'auteur. Peut contenir (par exemple)
113 * les clés : id_auteur, nom, login, email, statut, lang, ...
114 * @return bool|string
116 function ajouter_session($auteur) {
117 // Si le client a deja une session valide pour son id_auteur
118 // on conserve le meme fichier
120 // Attention un visiteur peut avoir une session et un id=0,
121 // => ne pas melanger les sessions des differents visiteurs
122 $id_auteur = isset($auteur['id_auteur']) ?
intval($auteur['id_auteur']) : 0;
124 // Si ce n'est pas un inscrit (les inscrits ont toujours des choses en session)
125 // on va vérifier s'il y a vraiment des choses à écrire
127 // On supprime les données de base pour voir le contenu réel de la session
128 $auteur_verif = $auteur;
129 if (isset($auteur_verif['id_auteur'])) {
130 unset($auteur_verif['id_auteur']);
132 if (isset($auteur_verif['hash_env'])) {
133 unset($auteur_verif['hash_env']);
135 if (isset($auteur_verif['ip_change'])) {
136 unset($auteur_verif['ip_change']);
138 if (isset($auteur_verif['date_session'])) {
139 unset($auteur_verif['date_session']);
142 // Les variables vraiment nulle ne sont pas à prendre en compte non plus
143 foreach ($auteur_verif as $variable => $valeur) {
144 if ($valeur === null) {
145 unset($auteur_verif[$variable]);
149 // Si après ça la session est vide alors on supprime l'éventuel fichier et on arrête là
150 if (!$auteur_verif) {
151 if (isset($_COOKIE['spip_session']) and isset($_SESSION[$_COOKIE['spip_session']])) {
152 unset($_SESSION[$_COOKIE['spip_session']]);
154 if (isset($_COOKIE['spip_session'])) {
155 unset($_COOKIE['spip_session']);
162 if (!isset($_COOKIE['spip_session'])
163 or !preg_match(',^' . $id_auteur . '_,', $_COOKIE['spip_session'])
165 $_COOKIE['spip_session'] = $id_auteur . '_' . md5(uniqid(rand(), true));
168 // Maintenant on sait qu'on a des choses à écrire
169 // On s'assure d'avoir au moins ces valeurs
170 $auteur['id_auteur'] = $id_auteur;
171 if (!isset($auteur['hash_env'])) {
172 $auteur['hash_env'] = hash_env();
174 if (!isset($auteur['ip_change'])) {
175 $auteur['ip_change'] = false;
178 if (!isset($auteur['date_session'])) {
179 $auteur['date_session'] = time();
181 if (isset($auteur['prefs'])
182 and is_string($auteur['prefs'])
183 and $prefs = @unserialize
($auteur['prefs'])) {
184 $auteur['prefs'] = $prefs;
187 $fichier_session = "";
189 // les sessions anonymes sont stockees dans $_SESSION
191 spip_php_session_start();
192 $_SESSION[$_COOKIE['spip_session']] = preparer_ecriture_session($auteur);
194 $fichier_session = fichier_session('alea_ephemere');
195 if (!ecrire_fichier_session($fichier_session, $auteur)) {
196 spip_log('Echec ecriture fichier session ' . $fichier_session, "session" . _LOG_HS
);
197 include_spip('inc/minipres');
201 // verifier et limiter le nombre maxi de sessions
202 // https://core.spip.net/issues/3807
203 lister_sessions_auteur($id_auteur);
206 // poser le cookie de session SPIP
207 include_spip('inc/cookie');
208 $duree = definir_duree_cookie_session($auteur);
209 spip_setcookie( 'spip_session', $_COOKIE['spip_session'], time() +
$duree);
210 spip_log("ajoute session $fichier_session cookie $duree", "session");
212 // Si on est admin, poser le cookie de correspondance
213 if (!function_exists('autoriser')) {
214 include_spip('inc/autoriser');
216 if (autoriser('ecrire','','',$auteur) and _DUREE_COOKIE_ADMIN
) {
217 spip_setcookie('spip_admin', '@' . $auteur['login'], time() +
max(_DUREE_COOKIE_ADMIN
, $duree));
218 } // sinon le supprimer ...
220 spip_setcookie('spip_admin', '', 1);
223 # on en profite pour purger les vieilles sessions anonymes abandonnees
224 # supprimer_sessions(0, true, false);
226 return $_COOKIE['spip_session'];
230 * Calcule le temps de validité en seconde du cookie de session
232 * Applique un coefficient multiplicateur à la durée de renouvellement de l'alea
233 * (noté ensuite `dR`, valant 12h par défaut) pour déterminer la durée du cookie.
235 * - `2 * dR`, par défaut
236 * - `20 * dR` si le visiteur a indiqué vouloir rester connecté quelques jours
237 * sur le formulaire de login (la clé `cookie` vaut alors `oui`)
238 * - `c * dR`, un coeficient défini manuellement si la clé `cookie` est numérique
240 * @param array $auteur
241 * Description de l'auteur
245 function definir_duree_cookie_session($auteur) {
247 if (isset($auteur['cookie'])) {
248 if (is_numeric($auteur['cookie'])) {
249 $coef = $auteur['cookie'];
254 return (int)(_RENOUVELLE_ALEA
* $coef);
258 * Vérifie si le cookie spip_session indique une session valide
260 * Si oui, la decrit dans le tableau $visiteur_session et retourne id_auteur
261 * La rejoue si IP change puis accepte le changement si $change=true
263 * Retourne false en cas d'echec, l'id_auteur de la session si defini, null sinon
265 * @uses spip_php_session_start() Si session anonyme
266 * @uses fichier_session()
267 * @uses ajouter_session()
270 * @param bool $change
271 * @return bool|int|null
273 function verifier_session($change = false) {
274 // si pas de cookie, c'est fichu
275 if (!isset($_COOKIE['spip_session'])) {
279 $fichier_session = "";
281 // est-ce une session anonyme ?
282 if (!intval($_COOKIE['spip_session'])) {
283 spip_php_session_start();
284 if (!isset($_SESSION[$_COOKIE['spip_session']]) or !is_array($_SESSION[$_COOKIE['spip_session']])) {
287 $GLOBALS['visiteur_session'] = $_SESSION[$_COOKIE['spip_session']];
289 // Tester avec alea courant
290 $fichier_session = fichier_session('alea_ephemere', true);
291 if ($fichier_session and @file_exists
($fichier_session)) {
292 include($fichier_session);
294 // Sinon, tester avec alea precedent
295 $fichier_session = fichier_session('alea_ephemere_ancien', true);
296 if (!$fichier_session or !@file_exists
($fichier_session)) {
300 // Renouveler la session avec l'alea courant
301 include($fichier_session);
302 spip_log('renouvelle session ' . $GLOBALS['visiteur_session']['id_auteur'], "session");
303 spip_unlink($fichier_session);
304 ajouter_session($GLOBALS['visiteur_session']);
308 // Compatibilite ascendante : auteur_session est visiteur_session si
309 // c'est un auteur SPIP authentifie (tandis qu'un visiteur_session peut
310 // n'etre qu'identifie, sans aucune authentification).
312 if (isset($GLOBALS['visiteur_session']['id_auteur']) and $GLOBALS['visiteur_session']['id_auteur']) {
313 $GLOBALS['auteur_session'] = &$GLOBALS['visiteur_session'];
317 // Si l'adresse IP change, inc/presentation mettra une balise image
318 // avec un URL de rappel demandant a changer le nom de la session.
319 // Seul celui qui a l'IP d'origine est rejoue
320 // ainsi un eventuel voleur de cookie ne pourrait pas deconnecter
321 // sa victime, mais se ferait deconnecter par elle.
322 if (hash_env() != $GLOBALS['visiteur_session']['hash_env']) {
323 if (!$GLOBALS['visiteur_session']['ip_change']) {
324 define('_SESSION_REJOUER', true);
325 $GLOBALS['visiteur_session']['ip_change'] = true;
326 ajouter_session($GLOBALS['visiteur_session']);
329 spip_log("session non rejouee, vol de cookie ?", "session");
334 spip_log("rejoue session $fichier_session " . $_COOKIE['spip_session'], "session");
335 if ($fichier_session) {
336 spip_unlink($fichier_session);
338 $GLOBALS['visiteur_session']['ip_change'] = false;
339 unset($_COOKIE['spip_session']);
340 ajouter_session($GLOBALS['visiteur_session']);
344 // Si la session a ete initiee il y a trop longtemps, elle est annulee
345 if (isset($GLOBALS['visiteur_session'])
346 and defined('_AGE_SESSION_MAX')
347 and _AGE_SESSION_MAX
> 0
348 and time() - @$GLOBALS['visiteur_session']['date_session'] > _AGE_SESSION_MAX
350 unset($GLOBALS['visiteur_session']);
355 return is_numeric($GLOBALS['visiteur_session']['id_auteur'])
356 ?
$GLOBALS['visiteur_session']['id_auteur']
361 * Lire une valeur dans la session SPIP
364 * @example `$login = session_get('login');`
367 * Clé dont on souhaite la valeur
369 * Valeur, si trouvée, `null` sinon.
371 function session_get($nom) {
372 return isset($GLOBALS['visiteur_session'][$nom]) ?
$GLOBALS['visiteur_session'][$nom] : null;
377 * Ajouter une donnée dans la session SPIP
380 * @uses ajouter_session()
381 * @uses terminer_actualiser_sessions() Ajoute la fonction en fin de hit.
387 function session_set($nom, $val = null) {
388 static $remove = array();
389 static $actualiser_sessions = false;
390 if ($nom === false) {
395 if (!isset($GLOBALS['visiteur_session'][$nom])) {
398 unset($GLOBALS['visiteur_session'][$nom]);
401 // On ajoute la valeur dans la globale
402 $GLOBALS['visiteur_session'][$nom] = $val;
404 $remove = array_diff($remove, array($nom));
407 if (!$actualiser_sessions) {
408 // il faut creer la session si on en a pas, la premiere fois
409 ajouter_session($GLOBALS['visiteur_session']);
410 // in register la fonction qui mettra a jour toutes les sessions en fin de hit
411 register_shutdown_function('terminer_actualiser_sessions');
412 $actualiser_sessions = true;
417 * En fin de hit, synchroniser toutes les sessions
419 * @uses actualiser_sessions()
421 function terminer_actualiser_sessions() {
422 // se remettre dans le dossier de travail au cas ou Apache a change
424 // recuperer les variables a effacer
425 $remove = session_set(false);
426 // mettre a jour toutes les sessions
427 actualiser_sessions($GLOBALS['visiteur_session'], $remove);
432 * Mettre à jour les sessions existantes pour un auteur
434 * Quand on modifie une fiche auteur on appelle cette fonction qui va
435 * mettre à jour les fichiers de session de l'auteur en question.
436 * (auteurs identifiés seulement)
438 * Ne concerne que les sessions des auteurs loges (id_auteur connu)
440 * @uses ajouter_session()
441 * @uses fichier_session()
443 * @uses preparer_ecriture_session()
444 * @uses ecrire_fichier_session()
446 * @param array $auteur
447 * @param array $supprimer_cles
448 * Liste des clés à supprimer des tableaux de sessions
450 function actualiser_sessions($auteur, $supprimer_cles = array()) {
452 $id_auteur = isset($auteur['id_auteur']) ?
intval($auteur['id_auteur']) : 0;
453 $id_auteur_courant = isset($GLOBALS['visiteur_session']['id_auteur']) ?
intval($GLOBALS['visiteur_session']['id_auteur']) : 0;
455 // si l'auteur est celui de la session courante, verifier/creer la session si besoin
456 $fichier_session_courante = "";
457 if ($id_auteur == $id_auteur_courant) {
458 $auteur = array_merge($GLOBALS['visiteur_session'], $auteur);
459 ajouter_session($auteur);
461 $fichier_session_courante = fichier_session('alea_ephemere');
465 // si session anonyme on ne fait rien d'autre ici : les sessions anonymes sont non partagees
470 // les préférences sont désérialisées, toujours.
471 if (isset($auteur['prefs']) and is_string($auteur['prefs'])) {
472 $auteur['prefs'] = unserialize($auteur['prefs']);
475 // memoriser l'auteur courant (celui qui modifie la fiche)
476 $sauve = $GLOBALS['visiteur_session'];
478 // .. mettre a jour les sessions de l'auteur cible
479 // attention au $ final pour ne pas risquer d'embarquer un .php.jeton temporaire
480 // cree par une ecriture concurente d'une session (fichier atomique temporaire)
481 $sessions = lister_sessions_auteur($id_auteur);
483 // 1ere passe : lire et fusionner les sessions
484 foreach ($sessions as $session) {
485 $GLOBALS['visiteur_session'] = array();
486 // a pu etre supprime entre le preg initial et le moment ou l'on arrive la (concurrence)
487 if ($session !== $fichier_session_courante
488 and @file_exists
($session)
490 include $session; # $GLOBALS['visiteur_session'] est alors l'auteur cible
492 $auteur = array_merge($GLOBALS['visiteur_session'], $auteur);
496 // supprimer les eventuelles cles dont on ne veut plus
497 foreach ($supprimer_cles as $cle) {
498 unset($auteur[$cle]);
501 $auteur_session = preparer_ecriture_session($auteur);
503 // seconde passe : ecrire les sessions qui ne sont pas a jour
504 foreach ($sessions as $session) {
505 $GLOBALS['visiteur_session'] = array();
506 // a pu etre supprime entre le preg initial et le moment ou l'on arrive la (concurrence)
507 if (@file_exists
($session)) {
508 include $session; # $GLOBALS['visiteur_session'] est alors l'auteur cible
510 // est-ce que cette session est a mettre a jour ?
511 if ($auteur_session != $GLOBALS['visiteur_session']) {
512 ecrire_fichier_session($session, $auteur);
517 if ($id_auteur == $id_auteur_courant) {
518 $GLOBALS['visiteur_session'] = $auteur;
519 $GLOBALS['auteur_session'] = &$GLOBALS['visiteur_session'];
521 // restaurer l'auteur courant
522 $GLOBALS['visiteur_session'] = $sauve;
528 * lister les sessions et en verifier le nombre maxi
529 * en supprimant les plus anciennes si besoin
530 * https://core.spip.net/issues/3807
532 * @param int $id_auteur
536 function lister_sessions_auteur($id_auteur, $nb_max = null) {
538 if (is_null($nb_max)) {
539 if (!defined('_NB_SESSIONS_MAX')) {
540 define('_NB_SESSIONS_MAX', 100);
542 $nb_max = _NB_SESSIONS_MAX
;
545 // liste des sessions
546 $sessions = preg_files(_DIR_SESSIONS
, '/' . $id_auteur . '_.*\.php$');
548 // si on en a plus que la limite, supprimer les plus vieilles
549 // si ce ne sont pas des sessions anonymes car elles sont alors chacune differentes
551 and count($sessions) > $nb_max) {
553 // limiter le nombre de sessions ouvertes par un auteur
554 // filemtime sur les sessions
555 $sessions = array_flip($sessions);
557 // 1ere passe : lire les filemtime
558 foreach ($sessions as $session => $z) {
559 if ($d = @filemtime
($session)
561 $sessions[$session] = $d;
563 $sessions[$session] = 0;
567 // les plus anciennes en premier
570 $sessions = array_keys($sessions);
571 while (count($sessions) > $nb_max) {
572 $session = array_shift($sessions);
582 * Préparer le tableau de session avant écriture
584 * Nettoyage de quelques variables sensibles, et appel d'un pipeline
586 * @pipeline preparer_fichier_session
587 * @param array $auteur
590 function preparer_ecriture_session($auteur) {
593 // ne pas enregistrer ces elements de securite
594 // dans le fichier de session
595 unset($auteur['pass']);
596 unset($auteur['htpass']);
597 unset($auteur['low_sec']);
598 unset($auteur['alea_actuel']);
599 unset($auteur['alea_futur']);
601 $auteur = pipeline('preparer_fichier_session', array('args' => array('row' => $row), 'data' => $auteur));
603 // ne pas enregistrer les valeurs vraiment nulle dans le fichier
604 foreach ($auteur as $variable => $valeur) {
605 if ($valeur === null) {
606 unset($auteur[$variable]);
614 * Ecrire le fichier d'une session
616 * @param string $fichier
617 * @param array $auteur
620 function ecrire_fichier_session($fichier, $auteur) {
622 $auteur = preparer_ecriture_session($auteur);
624 // enregistrer les autres donnees du visiteur
625 $texte = "<" . "?php\n";
626 foreach ($auteur as $var => $val) {
627 $texte .= '$GLOBALS[\'visiteur_session\'][' . var_export($var, true) . '] = '
628 . var_export($val, true) . ";\n";
630 $texte .= "?" . ">\n";
632 return ecrire_fichier($fichier, $texte);
637 * Calculer le nom du fichier session
639 * @param string $alea
640 * @param bool $tantpis
643 function fichier_session($alea, $tantpis = false) {
645 include_spip('inc/acces');
648 if (empty($GLOBALS['meta'][$alea])) {
650 spip_log("fichier session ($tantpis): $alea indisponible", "session");
651 include_spip('inc/minipres');
655 return ''; // echec mais $tanpis
657 $repertoire = sous_repertoire(_DIR_SESSIONS
, '', false, $tantpis);
658 $c = $_COOKIE['spip_session'];
660 return $repertoire . intval($c) . '_' . md5($c . ' ' . $GLOBALS['meta'][$alea]) . '.php';
666 * Code à insérer par `inc/presentation` pour rejouer la session
669 * Pourquoi insère-t-on le src par js et non directement en statique dans le HTML ?
670 * Historiquement, inséré par une balise `<script>` en r424
671 * puis modifié par `<img>` statique + js en r427
673 * @see action_cookie_dist() qui sera appelé
677 function rejouer_session() {
678 return '<img src="' . generer_url_action('cookie', 'change_session=oui', true) . '" width="0" height="0" alt="" />';
683 * On verifie l'IP et le nom du navigateur
687 function hash_env() {
693 return $res = md5($GLOBALS['ip'] . (isset($_SERVER['HTTP_USER_AGENT']) ?
$_SERVER['HTTP_USER_AGENT'] : ''));
698 * Démarre une session PHP si ce n'est pas déjà fait.
700 * @link http://php.net/manual/fr/function.session-start.php
701 * @uses is_php_session_started()
702 * @return bool True si une session PHP est ouverte.
704 function spip_php_session_start() {
705 if (!is_php_session_started()) {
706 return session_start();
713 * Indique si une sesssion PHP est active
715 * @link http://php.net/manual/fr/function.session-status.php#113468
716 * @return bool true si une session PHP est active
718 function is_php_session_started() {
719 if (php_sapi_name() !== 'cli') {
720 if (PHP_VERSION_ID
>= 50400) {
721 return session_status() === PHP_SESSION_ACTIVE ?
true : false;
723 return session_id() === '' ?
false : true;